﻿//using System;
//using System.Collections.Generic;
//using System.Linq;

//using OctoOS;
//using OctoOS.Services;

///// <summary>
///// Summary description for ApiService
///// </summary>
///// 



//public enum PublishCategoryIndexes
//{
//    StartPublish = 1,
//    StopPublish
//}

//public static class ApiService2
//{
//    private const long _mainCategoryID = 1;
//    private const long _publishCategoryID = 2;
//    private const int _maxMessageCount = 100;
//    const int _publishArticlesCheck = 10;

//    public static void DeleteAll(OOSRequest request)
//    {
//        List<MessageIn> mesIn = new List<MessageIn>();

//        var groups = OctoServices.Process(request,
//            new Post_GetGroups()).CastOrHttpException<Post_GetGroups_Response>();

//        if(groups.Groups != null)
//            foreach(var group in groups.Groups)
//            {
//                mesIn.Add(new Post_DeleteGroup(group.ID));
//            }

//        mesIn.Add(new Resource_SaveMeta(0, null));

//        var response = OctoServices.Process(request, mesIn.ToArray());
//        CheckResponse(response);
//    }

//    private static void CheckResponse(MessageOut[] messages)
//    {
//        foreach(var message in messages)
//            CheckResponse(message);
//    }

//    private static void CheckResponse(MessageOut message)
//    {
//        if(message as ErrorMessageResponse != null)
//            throw new ApplicationException();
//    }

//    public static void DeleteArticle(OOSRequest request, long id)
//    {
//        var response = OctoServices.Process(request,
//            new Post_DeleteEntity(id));

//        CheckResponse(response);
//    }

//    public static void AutoPublishArticles(OOSRequest request, DateTime checkTime)
//    {
//        List<MessageIn> publishMessages = new List<MessageIn>();
//        List<MessageIn> requestMessagesList = new List<MessageIn>();

//        requestMessagesList.Add(new Post_GetGroupThreadPreviews(
//            _publishCategoryID,
//            (int)PublishCategoryIndexes.StartPublish, 0, _publishArticlesCheck, false)
//        {
//            ReturnGroupIDs = true
//        });

//        requestMessagesList.Add(new Post_GetGroupThreadPreviews(
//            _publishCategoryID,
//            (int)PublishCategoryIndexes.StopPublish, 0, _publishArticlesCheck, false)
//        {
//            //ReturnGroupIDs = true
//        });

//        var responses = OctoServices.Process(request, requestMessagesList.ToArray());
//        for(int i = 0; i < responses.Length; i++)
//        {
//            var response = responses[i].CastOrHttpException<Post_GetGroupThreadPreviews_Response>();

//            if(response.Previews != null)
//            {
//                foreach(var preview in response.Previews)
//                {
//                    var previewMeta = ArticleMeta.Create(preview.Meta);

//                    //если дата старта/стопа статьи ещё не подошла тогда останавливаем цикл 
//                    if((requestMessagesList[i] as Post_GetGroupThreadPreviews).Index == (int)PublishCategoryIndexes.StartPublish)
//                    {
//                        if(previewMeta.PublishStartTime > DateTime.UtcNow)
//                        {
//                            continue;
//                        }
//                        else
//                        {
//                            //публикуем статью, обновляем группы - добавляем в группу юзера и все категории
//                            List<EntityIndex> indicies = new List<EntityIndex>();
//                            indicies.Add(new EntityIndex(_mainCategoryID));
//                            indicies.Add(new EntityIndex(previewMeta.UserID));
//                            foreach(var groupID in previewMeta.CategoryIDs)
//                                indicies.Add(new EntityIndex(groupID));

//                            //добавляем в группу остановки публикации если нужно
//                            var publishIndex = new EntityIndex(_publishCategoryID);
//                            if(previewMeta.PublishStopTime > DateTime.UtcNow && previewMeta.PublishStopTime != DateTime.MaxValue)
//                            {
//                                indicies.Add(new EntityIndex(_publishCategoryID)
//                                {
//                                    Index2 = IndexBuilder.GetBytes(previewMeta.PublishStopTime)
//                                });
//                            }

//                            publishMessages.Add(
//                                    new Post_UpdateEntityIndices(preview.ThreadID, indicies.ToArray()));

//                            publishMessages.Add(new Post_UpdateEntity(preview.ThreadID, preview.Title, false,
//                                previewMeta.ToArray()));
//                        }
//                    }
//                    else
//                    {
//                        if(previewMeta.PublishStopTime > DateTime.UtcNow)
//                        {
//                            continue;
//                        }
//                        else
//                        {
//                            //закрываем статью - оставляем только группу юзера
//                            publishMessages.Add(
//                                    new Post_UpdateEntityIndices(preview.ThreadID, new EntityIndex(previewMeta.UserID)));

//                            publishMessages.Add(new Post_UpdateEntity(preview.ThreadID, preview.Title, true,
//                                previewMeta.ToArray()));
//                        }
//                    }
//                }
//            }
//        }

//        if(publishMessages.Count > 0)
//            SendMessagesSafe(request, publishMessages.ToArray());
//    }

//    public static void InitResource(OOSRequest request)
//    {
//        var groups = OctoServices.Process(request,
//            new Post_GetGroups()).CastOrHttpException<Post_GetGroups_Response>();

//        bool found = false;
//        if(groups.Groups != null)
//        {
//            foreach(var group in groups.Groups)
//            {
//                if(group.ID == _mainCategoryID)
//                {
//                    found = true;
//                    break;
//                }
//            }
//        }

//        if(!found)
//        {
//            var responses = OctoServices.Process(request,
//                new Post_AddGroup(_mainCategoryID, string.Empty, null, true, false),
//                new Post_AddGroup(_publishCategoryID, string.Empty, null, false, false));

//            CheckResponse(responses);
//        }
//    }

//    public static void InsertCategory(OOSRequest request, string categoryName)
//    {
//        var catMeta = new GroupMeta(false, false);
//        var fCatMeta = new GroupMeta(false, true);

//        var messagesOut = OctoServices.Process(request,
//            new Post_AddGroup(request.RequestID, categoryName, catMeta.ToArray(), true, false),
//            new Post_AddGroup(request.RequestID + 1, categoryName, fCatMeta.ToArray(), true, false));

//        CheckResponse(messagesOut);
//    }

//    public static void UpdateCategory(OOSRequest request, long categoryID,
//        string categoryName)
//    {
//        var catMeta = new GroupMeta(false, false);
//        var fCatMeta = new GroupMeta(false, true);

//        var messagesOut = OctoServices.Process(request,
//            new Post_UpdateGroup(categoryID, categoryName, catMeta.ToArray()),
//            new Post_UpdateGroup(categoryID + 1, categoryName, fCatMeta.ToArray()));

//        CheckResponse(messagesOut);
//    }

//    public static void DeleteCategory(OOSRequest request, long categoryID)
//    {
//        var messagesOut = OctoServices.Process(request,
//            new Post_DeleteGroup(categoryID),
//            new Post_DeleteGroup(categoryID + 1));

//        CheckResponse(messagesOut);
//    }


//    public static Category[] GetCategories(OOSRequest request)
//    {
//        List<Category> categories = new List<Category>();

//        var groups = OctoServices.Process(request,
//            new Post_GetGroups()).CastOrHttpException<Post_GetGroups_Response>();

//        //считываем все группы кроме фичед, основных групп и юзеров
//        foreach(var group in groups.Groups.OrderBy(f => f.Name))
//        {
//            var meta = GroupMeta.Create(group.Meta);

//            if(group.ID != _mainCategoryID 
//                && group.ID != _publishCategoryID 
//                && !meta.UserGroup && !meta.Featured)
//            {
//                categories.Add(new Category(group.ID, group.Name));
//            }
//        }

//        return categories.ToArray();
//    }

//    public static Category GetCategory(OOSRequest request, long categoryID)
//    {
//        var allCategories = GetCategories(request);

//        foreach(var category in allCategories)
//        {
//            if(category.ID == categoryID)
//                return category;
//        }

//        return null;
//    }

//    public static Settings GetSettings(OOSRequest request)
//    {
//        var settings = OctoServices.Process(request,
//            new Resource_GetMeta()).CastOrHttpException<Resource_GetMeta_Response>();

//        return Settings.Create(settings.Meta.Value);
//    }

//    public static void SaveSettings(OOSRequest request, CommentsEnabled commentsEnabled,
//        CommentsModeration commentsModeration, FeedMode feedModeSelect,
//        int disableAfter, bool enableSubtitle, bool syndicatePosts, bool bookmarks,
//        bool sendToFriend, bool print, //bool trackBarUrl, 
//        bool commentRss)
//    {
//        Settings meta = new Settings(commentsEnabled,
//            commentsModeration, feedModeSelect, disableAfter, enableSubtitle,
//            syndicatePosts, bookmarks, sendToFriend, print, //trackBarUrl, 
//            commentRss);

//        var messageOut = OctoServices.Process(request,
//            new Resource_SaveMeta(0, meta.ToArray()));

//        CheckResponse(messageOut);
//    }

//    /// <summary>
//    /// Если возвращает true то нужно апдейтить ресурс
//    /// </summary>
//    public static void InsertArticle(OOSRequest request, string author,
//        string title, string preface, DateTime publishStartTime,
//        DateTime publishStopTime, long[] categoryIDs)
//    {
//        bool needToCreateUserGroup = false;
//        //проверка, существует ли группа пользователя
//        var resp = OctoServices.Process(request,
//            new Post_GetGroupsByID(request.UserID)).CastOrHttpException<Post_GetGroups_Response>();
//        if(resp.Groups == null || resp.Groups.Length == 0)
//            needToCreateUserGroup = true;


//        ArticleMeta meta = new ArticleMeta(preface, publishStartTime, publishStopTime,
//            request.UserID, author, DateTime.UtcNow, categoryIDs);

//        List<EntityIndex> indicies = new List<EntityIndex>();
//        indicies.Add(new EntityIndex(request.UserID));

//        #region previous mode
//        //добавляем в главную катгеорию с индексом по UserID и времени создания
//        //IndexBuilder iBuilder = new IndexBuilder();
//        //iBuilder.Add(meta.UserID);
//        //iBuilder.Add(meta.PublishedNow);
//        //iBuilder.Add(meta.CreateTime);

//        //IndexBuilder iBuilder2 = new IndexBuilder();
//        //iBuilder2.Add(meta.PublishedNow);
//        //iBuilder2.Add(meta.PublishStartTime);

//        //indicies.Add(new EntityIndex(_mainCategoryID) 
//        //{ 
//        //    Index1 = iBuilder.ToArray(),
//        //    Index2 = iBuilder2.ToArray()
//        //});

//        //добавляем в индекс по каждой из категорий
//        //foreach(var categoryID in categoryIDs)
//        //{
//        //    var indexBuilder = new IndexBuilder();
//        //    indexBuilder.Add(meta.PublishedNow);
//        //    indexBuilder.Add(publishStartTime);
//        //    indicies.Add(new EntityIndex(categoryID)
//        //    {
//        //        Index1 = indexBuilder.ToArray()
//        //    });
//        //}
//        #endregion

//        //если статья опубликована, то добавляем её в главную группу
//        //и каждую из категорий
//        if(meta.PublishedNow)
//        {
//            indicies.Add(new EntityIndex(_mainCategoryID));

//            //добавляем в индекс по каждой из категорий
//            foreach(var categoryID in categoryIDs)
//                indicies.Add(new EntityIndex(categoryID));
//        }

//        var publishIndex = new EntityIndex(_publishCategoryID);
//        if(publishStartTime > DateTime.UtcNow && publishStartTime != DateTime.MaxValue)
//            publishIndex.Index1 = IndexBuilder.GetBytes(publishStartTime);
		
//        if(publishStopTime > DateTime.UtcNow && publishStopTime != DateTime.MaxValue)
//            publishIndex.Index2 = IndexBuilder.GetBytes(publishStopTime);
		

//        if(publishIndex.Index1 != null || publishIndex.Index2 != null)
//            indicies.Add(publishIndex);

//        List<MessageIn> mesIn = new List<MessageIn>();
//        if(needToCreateUserGroup)
//        {
//            var groupMeta = new GroupMeta(true, false);
//            mesIn.Add(new Post_AddGroup(request.UserID, "user", groupMeta.ToArray(), true, false));
//        }
//        mesIn.Add(new Post_AddEntity(request.RequestID, title, meta.ToArray(),
//                indicies.ToArray()) { Locked = !meta.PublishedNow });
//        mesIn.Add(new Post_Add(request.RequestID, 1, 0, "", "", "", TextFormat.Html,
//            ContletFlags.AppRendering, null));

//        var messageOut = OctoServices.Process(request, mesIn.ToArray());
//        CheckResponse(messageOut);
//    }


//    public static void UpdateArticle(OOSRequest request, long articleID,
//        string author, string title, string preface, DateTime publishStartTime,
//        DateTime publishStopTime, long[] categoryIDs)
//    {
//        var currentArticle = OctoServices.Process(request,
//            new Post_GetThread(articleID)
//            ).CastOrHttpException<Post_GetThread_Response>();
//        var currentMeta = ArticleMeta.Create(currentArticle.Thread.Meta);

//        currentMeta.Preface = preface;

//        currentMeta.Author = author;
//        //currentMeta.Published = published;
//        currentMeta.PublishStartTime = publishStartTime;
//        currentMeta.PublishStopTime = publishStopTime;
//        currentMeta.CategoryIDs = categoryIDs;

//        List<EntityIndex> indicies = new List<EntityIndex>();
//        indicies.Add(new EntityIndex(currentMeta.UserID));

//        //добавляем в главную группу только если уже опубликовано
//        if(currentMeta.PublishedNow)
//        {
//            indicies.Add(new EntityIndex(_mainCategoryID));

//            foreach(var categoryID in categoryIDs)
//                indicies.Add(new EntityIndex(categoryID));
//        }

//        //расписание публикаций
//        var publishIndex = new EntityIndex(_publishCategoryID);
//        if(publishStartTime > DateTime.UtcNow && publishStartTime != DateTime.MaxValue)
//            publishIndex.Index1 = IndexBuilder.GetBytes(publishStartTime);

//        if(publishStopTime > DateTime.UtcNow && publishStopTime != DateTime.MaxValue)
//            publishIndex.Index2 = IndexBuilder.GetBytes(publishStopTime);
		
//        if(publishIndex.Index1 != null || publishIndex.Index2 != null)
//            indicies.Add(publishIndex);

//        //construct messagesIn	
//        List<MessageIn> messagesIn = new List<MessageIn>();
//        messagesIn.Add(new Post_UpdateEntity(articleID, title, !currentMeta.PublishedNow, currentMeta.ToArray()));
//        messagesIn.Add(new Post_UpdateEntityIndices(articleID, indicies.ToArray()));

//        var messagesOut = OctoServices.Process(request, messagesIn.ToArray());
//        CheckResponse(messagesOut);
//    }

//    public static Post_GetThread_Response GetThread(OOSRequest request, long id)
//    {
//        return OctoServices.Process(request,
//            new Post_GetThread(id) { ReturnGroupIndices = true }
//            ) as Post_GetThread_Response;
//    }

//    public static Article[] GetArticles(OOSRequest request, long[] ids)
//    {
//        List<Article> articles = new List<Article>();
//        List<MessageIn> messagesIn = new List<MessageIn>();

//        foreach(var id in ids)
//        {
//            messagesIn.Add(new Post_GetThread(id)
//                {
//                    ReturnGroupIndices = true,
//                    ReturnPosts = true
//                });
//            messagesIn.Add(new Post_GetAllBodies(id));
//        }

//        var responses = OctoServices.Process(request, messagesIn.ToArray());
//        int i = 0;
//        while(i < responses.Length)
//        {
//            var allBodies = responses[i + 1].CastOrHttpException<Post_GetAllBodies_Response>();
//            var article = responses[i].CastOrHttpException<Post_GetThread_Response>();

//            var articleMeta = ArticleMeta.Create(article.Thread.Meta);

//            //categories
//            List<long> categories = new List<long>();
//            foreach(var group in article.Indices)
//                categories.Add(group.GroupID);

//            //pages and sections
//            List<Page> pages = new List<Page>();
//            foreach(var pageID in articleMeta.PagesOrder)
//            {
//                foreach(var currentPage in article.Thread.Contlets)
//                {
//                    if(pageID == currentPage.ID)
//                    {
//                        List<Section> sections = new List<Section>();
//                        var pageMeta = PageMeta.Create(currentPage.Meta);

//                        foreach(var sectionID in pageMeta.SectionsOrder)
//                        {
//                            foreach(var section in currentPage.Contlets)
//                            {
//                                if(section.ID == sectionID)
//                                {
//                                    //var sectionMeta = SectionMeta.Create(section.Meta);
//                                    var sectionBody = allBodies.GetBody(section.ID);
//                                    sections.Add(new Section(section.ID, "sectino title",
//                                        sectionBody.Text, sectionBody.Format));
//                                    break;
//                                }
//                            }
//                        }

//                        pages.Add(new Page(pageID, currentPage.Title, pageMeta.Status, sections.ToArray()));
//                        break;
//                    }
//                }
//            }

//            articles.Add(new Article(article.ThreadID, articleMeta.Author, 
//                article.Thread.Title, articleMeta.Preface,
//                categories.ToArray(), pages.ToArray(),
//                articleMeta.PublishStartTime, 
//                articleMeta.PublishStopTime, articleMeta.CreateTime,
//                articleMeta.UserID));
//        }

//        return articles.ToArray();
//    }

//    public static Article GetArticle(OOSRequest request, long id)
//    {
//        var responses = OctoServices.Process(request,
//            new Post_GetThread(id) { ReturnPosts = true },
//            new Post_GetAllBodies(id));

//        var allBodies = responses[1].CastOrHttpException<Post_GetAllBodies_Response>();
//        var article = responses[0].CastOrHttpException<Post_GetThread_Response>();

//        var articleMeta = ArticleMeta.Create(article.Thread.Meta);
		
//        //pages and sections
//        List<Page> pages = new List<Page>();
//        foreach(var pageID in articleMeta.PagesOrder)
//        {
//            foreach(var currentPage in article.Thread.Contlets)
//            {
//                if(pageID == currentPage.ID)
//                {
//                    List<Section> sections = new List<Section>();
//                    var pageMeta = PageMeta.Create(currentPage.Meta);

//                    foreach(var sectionID in pageMeta.SectionsOrder)
//                    {
//                        foreach(var section in currentPage.Contlets)
//                        {
//                            if(section.ID == sectionID)
//                            {
//                                //var sectionMeta = SectionMeta.Create(section.Meta);
//                                var sectionBody = allBodies.GetBody(section.ID);
//                                sections.Add(new Section(section.ID, section.Title, 
//                                    sectionBody.Text, sectionBody.Format));
//                                break;
//                            }
//                        }
//                    }

//                    pages.Add(new Page(pageID, currentPage.Title, pageMeta.Status, sections.ToArray()));
//                    break;
//                }
//            }
//        }

//        return new Article(id, articleMeta.Author, article.Thread.Title, 
//            articleMeta.Preface, articleMeta.CategoryIDs, pages.ToArray(), 
//            articleMeta.PublishStartTime, articleMeta.PublishStopTime,
//            articleMeta.CreateTime, articleMeta.UserID);
//    }

//    public static Section GetSection(OOSRequest request, long articleID, long sectionID)
//    {
//        var responses = OctoServices.Process(request,
//            new Post_GetThread(articleID) { ReturnPosts = true },
//            new Post_GetBodies(articleID, sectionID));
//        CheckResponse(responses);

//        var article = responses[0] as Post_GetThread_Response;
//        var bodies = responses[1] as Post_GetBodies_Response;
//        var currentBody = bodies.GetBody(sectionID);

//        var section = article.Thread.GetContlet(sectionID);
//        if(section == null)
//            throw new ApplicationException();
//        //var postMeta = SectionMeta.Create(section.Meta);

//        return new Section(sectionID, section.Title, currentBody.Text, currentBody.Format);
//    }

//    public static void InsertSection(OOSRequest request, long articleID, long pageID,
//        string name,  string content, TextFormat format)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID) { ReturnPosts = true }
//            ).CastOrHttpException<Post_GetThread_Response>();

//        var page = article.Thread.GetContlet(pageID);
//        if(page == null)
//            throw new ApplicationException();
//        var pageMeta = PageMeta.Create(page.Meta);
//        pageMeta.AddSection(request.RequestID);

//        //var sectionMeta = new SectionMeta(name);

//        var messagesOut = OctoServices.Process(request,
//            new Post_Update(articleID, pageID, string.Empty, page.Title, string.Empty, TextFormat.Plain,
//                ContletFlags.AppRendering, pageMeta.ToArray(), "update"),
//            new Post_Add(articleID, request.RequestID, pageID, string.Empty, name,
//                content, format, ContletFlags.AppRendering, null));

//        CheckResponse(messagesOut);
//    }

//    public static void UpdateSection(OOSRequest request, long threadID, long sectionID,
//        string name, string content, TextFormat format)
//    {
//        //var meta = new SectionMeta(name);
//        var messageOut = OctoServices.Process(request,
//            new Post_Update(threadID, sectionID, string.Empty, null, content, format,
//                ContletFlags.AppRendering, null, "update"));

//        CheckResponse(messageOut);
//    }

//    public static void DeleteSection(OOSRequest request, long articleID, long pageID,
//        long sectionID)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID) { ReturnPosts = true }
//            ).CastOrHttpException<Post_GetThread_Response>();

//        var page = article.Thread.GetContlet(pageID);
//        if(page == null)
//            throw new ApplicationException();
//        var pageMeta = PageMeta.Create(page.Meta);
//        pageMeta.DeleteSection(request.RequestID);

//        var responses = OctoServices.Process(request,
//            new Post_Update(articleID, pageID, string.Empty, null, string.Empty, TextFormat.Plain,
//                ContletFlags.AppRendering, pageMeta.ToArray(), "update"),
//            new Post_Delete(articleID, sectionID));

//        CheckResponse(responses);
//    }


//    public static void InsertPage(OOSRequest request, long articleID, string name,
//        PageStatus status)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID)).CastOrHttpException<Post_GetThread_Response>();
//        var articleMeta = ArticleMeta.Create(article.Thread.Meta);
//        articleMeta.AddPage(request.RequestID, status);

//        var pageMeta = new PageMeta(status);
		 
//        var responses = OctoServices.Process(request,
//            new Post_UpdateEntity(articleID, article.Thread.Title, !articleMeta.PublishedNow, articleMeta.ToArray()),
//            new Post_Add(articleID, request.RequestID, 0, string.Empty, name, string.Empty,
//                TextFormat.Plain, ContletFlags.AppRendering, pageMeta.ToArray()));

//        CheckResponse(responses);
//    }


//    public static void DeletePage(OOSRequest request, long articleID, long pageID)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID)
//            {
//                ReturnPosts = true
//            }).CastOrHttpException<Post_GetThread_Response>();
//        var articleMeta = ArticleMeta.Create(article.Thread.Meta);
//        var page = article.Thread.GetContlet(pageID);
//        var pageMeta = PageMeta.Create(page.Meta);

//        articleMeta.DeletePage(pageID, pageMeta.Status);

//        var responses = OctoServices.Process(request,
//            new Post_UpdateEntity(articleID, article.Thread.Title, !articleMeta.PublishedNow, articleMeta.ToArray()),
//            new Post_Delete(articleID, pageID));

//        CheckResponse(responses);
//    }



//    public static CategoryArticlePreview[] GetCategoryArticles(OOSRequest request,
//        long categoryID, int offset, int count, out int totalCount)
//    {
//        List<CategoryArticlePreview> previews = new List<CategoryArticlePreview>();
//        totalCount = 0;

//        var responses = OctoServices.Process(request,
//            //get articles for featured category
//            new Post_GetGroupThreadPreviews2(categoryID + 1, true, offset, count, true)
//            {
//                ReturnTotalCount = true
//            },
//            //get articles for not featured category
//            new Post_GetGroupThreadPreviews2(categoryID, true,
//                offset - AppUtil.maxFeaturedCnt,
//                count + AppUtil.maxFeaturedCnt,
//                true)
//            {
//                ReturnTotalCount = true
//            });

//        //featured
//        var featuredResponse = responses[0].CastOrHttpException<Post_GetGroupThreadPreviews_Response>();
//        totalCount += featuredResponse.TotalCount;
//        if(featuredResponse.Previews != null)
//        {
//            foreach(var preview in featuredResponse.Previews)
//            {
//                var meta = ArticleMeta.Create(preview.Meta);

//                previews.Add(new CategoryArticlePreview(preview.ThreadID, preview.Title, meta.Preface, meta.PublishStopTime,
//                    meta.PublishStartTime, meta.Author, true, meta.CreateTime, meta.UserID));
//            }
//        }

//        //not featured
//        var regularResponse = responses[1].CastOrHttpException<Post_GetGroupThreadPreviews_Response>();
//        totalCount += regularResponse.TotalCount;
//        if(previews.Count < count)
//        {
//            if(regularResponse.Previews != null)
//            {
//                int startIndex = offset - regularResponse.TotalCount + 1;
//                if(startIndex < 0)
//                    startIndex = 0;

//                for(int i = startIndex; i < regularResponse.TotalCount; i++)
//                //foreach(var preview in regularResponse.Previews)
//                {
//                    var preview = regularResponse.Previews[i];
//                    var meta = ArticleMeta.Create(preview.Meta);

//                    previews.Add(new CategoryArticlePreview(preview.ThreadID, preview.Title, meta.Preface, meta.PublishStopTime,
//                        meta.PublishStartTime, meta.Author, false, meta.CreateTime, meta.UserID));

//                    if(previews.Count == count)
//                        break;
//                }
//            }
//        }

//        return previews.ToArray();
//    }

//    public static MyPageArticlePreview[] GetMyArticles(OOSRequest request,
//        int offset, int count, out int totalCount)
//    {
//        List<MyPageArticlePreview> articles = new List<MyPageArticlePreview>();
//        totalCount = 0;

//        //проверка, существует ли группа пользователя
//        var resp = OctoServices.Process(request,
//            new Post_GetGroupsByID(request.UserID),
//            new Post_GetGroupThreadPreviews2(request.UserID, true,
//                    offset, count, true)
//            {
//                //ReturnGroupIDs = true, 
//                ReturnTotalCount = true
//            });
			
//        var groups = resp[0].CastOrHttpException<Post_GetGroups_Response>();
//        if(groups.Groups == null || groups.Groups.Length == 0)
//        {
//            //если группы нет то создаём группу
//            //и возвращаем пустой массив превьюшек
//            var meta = new GroupMeta(true, false);
//            var response = OctoServices.Process(request,
//                new Post_AddGroup(request.UserID, "", meta.ToArray(), true, false));
//            CheckResponse(response);
//        }
//        else
//        {
			
//            var response = resp[1].CastOrHttpException<Post_GetGroupThreadPreviews_Response>();

//            totalCount = response.TotalCount;
//            if(response.Previews != null)
//            {
//                foreach(var preview in response.Previews)
//                {
//                    var articleMeta = ArticleMeta.Create(preview.Meta);

//                    articles.Add(
//                        new MyPageArticlePreview(preview.ThreadID, preview.Title, articleMeta.Preface, articleMeta.CategoryIDs,
//                            articleMeta.CreateTime, articleMeta.PublishStartTime, articleMeta.PublishStopTime,
//                            articleMeta.PagesOrder, articleMeta.NonCompletePages, articleMeta.UserID, articleMeta.Author));
//                }
//            }
//        }
//        return articles.ToArray();
//    }

//    public static void SavePagesOrder(OOSRequest request, long articleID,
//        long[] newPagesOrder)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID)).CastOrHttpException<Post_GetThread_Response>();

//        var articleMeta = ArticleMeta.Create(article.Thread.Meta);
//        articleMeta.PagesOrder = newPagesOrder;
//        var response = OctoServices.Process(request,
//            new Post_UpdateEntity(articleID, article.Thread.Title, !articleMeta.PublishedNow, 
//                articleMeta.ToArray()));

//        CheckResponse(response);
//    }

//    public static void SaveSectionsOrder(OOSRequest request, long articleID,
//        long pageID, long[] newSectionsOrder)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID) { ReturnPosts = true }
//            ).CastOrHttpException<Post_GetThread_Response>();

//        var page = article.Thread.GetContlet(pageID);
//        var pageMeta = PageMeta.Create(page.Meta);
//        pageMeta.SectionsOrder = newSectionsOrder;

//        var response = OctoServices.Process(request,
//            new Post_Update(articleID, pageID, string.Empty, page.Title, string.Empty,
//                TextFormat.Plain, ContletFlags.AppRendering, pageMeta.ToArray(),
//                "update"));

//        CheckResponse(response);
//    }

//    public static void UpdatePage(OOSRequest request, long articleID, long pageID,
//        string title, PageStatus status)
//    {
//        var article = OctoServices.Process(request,
//            new Post_GetThread(articleID) { ReturnPosts = true }
//            ).CastOrHttpException<Post_GetThread_Response>();
//        var articleMeta = ArticleMeta.Create(article.Thread.Meta);

//        var page = article.Thread.GetContlet(pageID);
//        var pageMeta = PageMeta.Create(page.Meta);

//        if(pageMeta.Status == PageStatus.Completed)
//        {
//            if(status != PageStatus.Completed)
//                articleMeta.AddNonCompletedPageID(pageID);
//        }
//        else
//        {
//            if(status == PageStatus.Completed)
//                articleMeta.DeleteNonCompletedPageID(pageID); 
//        }

//        pageMeta.Status = status;

//        var responses = OctoServices.Process(request,
//            new Post_UpdateEntity(articleID, article.Thread.Title, !articleMeta.PublishedNow, articleMeta.ToArray()),
//            new Post_Update(articleID, pageID, string.Empty, title, string.Empty, TextFormat.Plain,
//                ContletFlags.AppRendering, pageMeta.ToArray(), string.Empty));

//        CheckResponse(responses);
//    }

//    public static MainPageArticlePreview[] GetMainPreviews(OOSRequest request,
//        int offset, int count, out int totalCount)
//    {
//        List<MainPageArticlePreview> result = new List<MainPageArticlePreview>();

//        var previews = OctoServices.Process(request,
//            new Post_GetGroupThreadPreviews2(_mainCategoryID,
//                true, offset, count, true)
//                {
//                    //ReturnGroupIDs = true,
//                    ReturnTotalCount = true
//                }).CastOrHttpException<Post_GetGroupThreadPreviews_Response>();

//        totalCount = previews.TotalCount;
//        if(previews.Previews != null)
//        {
//            foreach(var preview in previews.Previews)
//            {
//                var meta = ArticleMeta.Create(preview.Meta);

//                result.Add(new MainPageArticlePreview(preview.ThreadID, preview.Title, meta.Preface, meta.PublishStartTime,
//                    meta.PublishStopTime, meta.Author, meta.CreateTime, meta.UserID, meta.CategoryIDs));
//            }
//        }

//        return result.ToArray();
//    }

//    public static void SendMessagesSafe(OOSRequest request, MessageIn[] messages)
//    {
//        List<MessageIn> messagePacket = new List<MessageIn>();

//        for(int i = 0; i < messages.Length; i++)
//        {
//            messagePacket.Add(messages[i]);
//            if((i + 1) % _maxMessageCount == 0)
//            {
//                var response = OctoServices.Process(request, messages.ToArray());
//                CheckResponse(response);
//                messagePacket.Clear();
//            }
//        }

//        if(messagePacket.Count > 0)
//        {
//            var response = OctoServices.Process(request, messages.ToArray());
//            CheckResponse(response);
//        }
//    }
//}